<?php

use ApiPlatform\JsonSchema\SchemaFactoryInterface;
use Mcp\Capability\Discovery\SchemaGeneratorInterface;
use Mcp\Server\Builder;

class ApiPlatformSchemaGenerator implements SchemaGeneratorInterface
{
    public function __construct(
        private SchemaFactoryInterface $schemaFactory,
    ) {}

    public function generate(\Reflector $reflection): array
    {
        if (!$reflection instanceof \ReflectionMethod && !$reflection instanceof \ReflectionFunction) {
            throw new \InvalidArgumentException('Only methods and functions are supported');
        }

        $properties = [];
        $required = [];

        foreach ($reflection->getParameters() as $parameter) {
            $paramType = $parameter->getType();
            
            // For complex types, use API Platform to generate schema
            if ($paramType instanceof \ReflectionNamedType && !$paramType->isBuiltin()) {
                $className = $paramType->getName();
                $schema = $this->schemaFactory->buildSchema($className);
                $properties[$parameter->getName()] = $schema['properties'] ?? [];
            } else {
                // Fallback to simple types
                $properties[$parameter->getName()] = [
                    'type' => $this->mapPhpTypeToJsonSchema($paramType),
                ];
            }

            if (!$parameter->isOptional()) {
                $required[] = $parameter->getName();
            }
        }

        return [
            'type' => 'object',
            'properties' => $properties,
            'required' => $required,
        ];
    }

    private function mapPhpTypeToJsonSchema(?\ReflectionType $type): string
    {
        if (!$type instanceof \ReflectionNamedType) {
            return 'string';
        }

        return match ($type->getName()) {
            'int' => 'integer',
            'float' => 'number',
            'bool' => 'boolean',
            'array' => 'array',
            default => 'string',
        };
    }
}

// Usage with Builder
$schemaFactory = /* get API Platform schema factory */;
$generator = new ApiPlatformSchemaGenerator($schemaFactory);

$server = Builder::create()
    ->setSchemaGenerator($generator)
    ->discover(__DIR__ . '/tools')
    ->build();

<?php

use PHPModelGenerator\SchemaGenerator\SchemaGeneratorInterface as PHPSchemaGeneratorInterface;
use Mcp\Capability\Discovery\SchemaGeneratorInterface;
use Mcp\Server\Builder;

class PHPModelSchemaGenerator implements SchemaGeneratorInterface
{
    public function __construct(
        private PHPSchemaGeneratorInterface $phpSchemaGenerator,
    ) {}

    public function generate(\Reflector $reflection): array
    {
        if (!$reflection instanceof \ReflectionMethod && !$reflection instanceof \ReflectionFunction) {
            throw new \InvalidArgumentException('Only methods and functions are supported');
        }

        $properties = [];
        $required = [];

        foreach ($reflection->getParameters() as $parameter) {
            $paramType = $parameter->getType();
            
            // If parameter is a class, generate its schema
            if ($paramType instanceof \ReflectionNamedType && class_exists($paramType->getName())) {
                $className = $paramType->getName();
                
                // Generate a temporary JSON Schema file for the class
                $tempSchema = $this->generateSchemaForClass($className);
                $properties[$parameter->getName()] = $tempSchema;
            } else {
                // Simple type
                $properties[$parameter->getName()] = [
                    'type' => $this->getJsonSchemaType($paramType),
                ];
            }

            if (!$parameter->isOptional()) {
                $required[] = $parameter->getName();
            }
        }

        return [
            'type' => 'object',
            'properties' => $properties,
            'required' => $required,
        ];
    }

    private function generateSchemaForClass(string $className): array
    {
        // Use reflection to build a schema from class properties
        $reflection = new \ReflectionClass($className);
        $properties = [];

        foreach ($reflection->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) {
            $type = $property->getType();
            $properties[$property->getName()] = [
                'type' => $this->getJsonSchemaType($type),
                'description' => $this->extractDescription($property),
            ];
        }

        return [
            'type' => 'object',
            'properties' => $properties,
        ];
    }

    private function getJsonSchemaType(?\ReflectionType $type): string
    {
        if (!$type instanceof \ReflectionNamedType) {
            return 'string';
        }

        return match ($type->getName()) {
            'int' => 'integer',
            'float', 'double' => 'number',
            'bool' => 'boolean',
            'array' => 'array',
            default => 'string',
        };
    }

    private function extractDescription(\ReflectionProperty $property): string
    {
        $docComment = $property->getDocComment();
        if (!$docComment) {
            return '';
        }

        // Simple extraction of description from docblock
        preg_match('/@var\s+\S+\s+(.+)/', $docComment, $matches);
        return $matches[1] ?? '';
    }
}

// Usage
$phpSchemaGenerator = /* initialize php-json-schema-model-generator */;
$generator = new PHPModelSchemaGenerator($phpSchemaGenerator);

$server = Builder::create()
    ->setSchemaGenerator($generator)
    ->discover(__DIR__ . '/tools')
    ->build();

<?php

use Spiral\JsonSchema\Generator;
use Mcp\Capability\Discovery\SchemaGeneratorInterface;
use Mcp\Server\Builder;

class SpiralSchemaGenerator implements SchemaGeneratorInterface
{
    public function __construct(
        private Generator $spiralGenerator,
    ) {}

    public function generate(\Reflector $reflection): array
    {
        if (!$reflection instanceof \ReflectionMethod && !$reflection instanceof \ReflectionFunction) {
            throw new \InvalidArgumentException('Only methods and functions are supported');
        }

        $properties = [];
        $required = [];

        foreach ($reflection->getParameters() as $parameter) {
            $paramType = $parameter->getType();
            
            if ($paramType instanceof \ReflectionNamedType) {
                // Use Spiral to generate schema for complex types
                if (class_exists($paramType->getName()) || interface_exists($paramType->getName())) {
                    $schema = $this->spiralGenerator->generate($paramType->getName());
                    $properties[$parameter->getName()] = $schema;
                } else {
                    $properties[$parameter->getName()] = [
                        'type' => $this->mapType($paramType->getName()),
                    ];
                }
            } elseif ($paramType instanceof \ReflectionUnionType) {
                // Handle union types with anyOf
                $types = [];
                foreach ($paramType->getTypes() as $type) {
                    if ($type instanceof \ReflectionNamedType) {
                        $types[] = ['type' => $this->mapType($type->getName())];
                    }
                }
                $properties[$parameter->getName()] = [
                    'anyOf' => $types,
                ];
            }

            if (!$parameter->isOptional()) {
                $required[] = $parameter->getName();
            }
        }

        return [
            'type' => 'object',
            'properties' => $properties,
            'required' => $required,
        ];
    }

    private function mapType(string $typeName): string
    {
        return match ($typeName) {
            'int' => 'integer',
            'float', 'double' => 'number',
            'bool' => 'boolean',
            'array' => 'array',
            'object' => 'object',
            'null' => 'null',
            default => 'string',
        };
    }
}

// Usage
$spiralGenerator = new Generator();
$generator = new SpiralSchemaGenerator($spiralGenerator);

$server = Builder::create()
    ->setSchemaGenerator($generator)
    ->discover(__DIR__ . '/tools')
    ->build();